home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / news / selectv1.tar / selectv1 / dllist.c < prev    next >
C/C++ Source or Header  |  1993-09-04  |  3KB  |  208 lines
  1. /*
  2. dllist.c: doubly linked lists for selectnews;
  3.           originally a C++ file called 'eeklist.c'
  4.  
  5. Copyright (C) 1993 Eugene Eric Kim
  6. All rights reserved.
  7.  
  8. LAST REVISION: September 4, 1993
  9. */
  10.  
  11. #include <malloc.h>
  12. #include <string.h>
  13. #include "dllist.h"
  14.  
  15. void list_create(dllist* l)
  16. {
  17.   (*l).head = 0;
  18. }
  19.  
  20. node* list_next(node* w)
  21. {
  22.   return (*w).next;
  23. }
  24.  
  25. node* list_prev(node* w)
  26. {
  27.   return (*w).prev;
  28. }
  29.  
  30. int list_size(dllist l)
  31. {
  32.   int i = 0;
  33.   node* temp;
  34.  
  35.   temp = l.head;
  36.   while (temp != 0) {
  37.     temp = (*temp).next;
  38.     i++;
  39.   }
  40.   return i;
  41. }
  42.  
  43. short list_empty(dllist l)
  44. {
  45.   return l.head ? 0 : 1;
  46. }
  47.  
  48. short list_first(node* w)
  49. {
  50.   if (w==0)
  51.     return 1;
  52.   else
  53.     return (*w).prev ? 0 : 1;
  54. }
  55.  
  56. short list_last(node* w)
  57. {
  58.   if (w==0)
  59.     return 1;
  60.   else
  61.     return (*w).next ? 0 : 1;
  62. }
  63.  
  64. node* list_start(dllist l)
  65. {
  66.   return l.head;
  67. }
  68.  
  69. node* list_end(dllist l)
  70. {
  71.   node* temp;
  72.  
  73.   temp = l.head;
  74.   if (temp != 0)
  75.     while ((*temp).next != 0 ) temp = (*temp).next;
  76.   return temp;
  77. }
  78.  
  79. node* list_position(dllist l,int i)
  80. /* if i is illegal, returns 0 */
  81. {
  82.   node* temp;
  83.   int j = 0;
  84.  
  85.   temp = l.head;
  86.   if ( (i>=0) && (i<list_size(l)) ) {
  87.     while (j<i) {
  88.       temp = (*temp).next;
  89.       j++;
  90.     }
  91.     return temp;
  92.   }
  93.   else
  94.     return 0;
  95. }
  96.  
  97. node* list_del(dllist* l,node* w)
  98. {
  99.   node* p;
  100.   node* n;
  101.  
  102.   if (w!=0) {
  103.     p = (*w).prev;
  104.     n = (*w).next;
  105.     if (n!=0) (*n).prev = p;
  106.     if (p!=0) (*p).next = n;
  107.     else (*l).head = n; /* if p == 0 then w = head */
  108.     (*w).prev = 0;
  109.     (*w).next = 0;
  110.     free(w);
  111.   }
  112.   if (n!=0)
  113.     return n;
  114.   else
  115.     return p;
  116. }
  117.  
  118. node* list_insafter(dllist* l, node* w, char item[LEN])
  119. {
  120.   node* temp = malloc(sizeof(node));
  121.   node* n;
  122.  
  123.   strcpy((*temp).entry,item);
  124.   if (w == 0) { /* => w==head */
  125.     (*temp).next = (*temp).prev = 0;
  126.     w = temp;
  127.     (*l).head = w;
  128.   }
  129.   else {
  130.     if ((*w).next != 0) {
  131.       n = (*w).next;
  132.       (*temp).next = n;
  133.       (*n).prev = temp;
  134.     }
  135.     (*w).next = temp;
  136.     (*temp).prev = w;
  137.   }
  138.   return temp;
  139. }
  140.  
  141. node* list_insbefore(dllist* l, node* w, char item[LEN])
  142. {
  143.   node* temp = malloc(sizeof(node));
  144.   node* p;
  145.   int ishead = 0;
  146.  
  147.   strcpy((*temp).entry,item);
  148.   if (w == 0) { /* => w==head */
  149.     (*temp).next = (*temp).prev = 0;
  150.     w = temp;
  151.     (*l).head = w;
  152.   }
  153.   else {
  154.     if ((*w).prev != 0) { /* if w != head */
  155.       p = (*w).prev;
  156.       (*temp).prev = p;
  157.       (*p).next = temp;
  158.     }
  159.     else ishead = 1;
  160.     (*w).prev = temp;
  161.     (*temp).next = w;
  162.     if (ishead) (*l).head = temp;
  163.   }
  164.   return temp;
  165. }
  166.  
  167. void list_replace(dllist* l,node* w, char item[LEN])
  168. {
  169.   strcpy((*w).entry,item);
  170. }
  171.  
  172. void list_interchange(dllist* l, node* w, node* v)
  173. {
  174.   char temp[LEN];
  175.  
  176.   strcpy(temp,(*w).entry);
  177.   strcpy((*w).entry,(*v).entry);
  178.   strcpy((*v).entry,temp);
  179. }
  180.  
  181. void list_traverse(dllist l,void (*visit)(node* w))
  182. {
  183.   node* c;
  184.  
  185.   c = l.head;
  186.   while (c != 0) {
  187.     (*visit)(c);
  188.     c = (*c).next;
  189.   }
  190. }
  191.  
  192. void list_clear(dllist* l)
  193. {
  194.   node* temp = list_end(*l);
  195.   node* curr;
  196.  
  197.   while (!temp && (temp != 0)) {
  198.     curr = (*temp).prev;
  199.     if ((*temp).prev)
  200.       free((*temp).prev);
  201.     if ((*temp).next)
  202.       free((*temp).next);
  203.     free(temp);
  204.     temp = curr;
  205.   }
  206.   (*l).head = 0;
  207. }
  208.